package com.zdxlz.fcmp.common.core.util;

import cn.hutool.core.util.StrUtil;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import java.util.stream.Collectors;

import static com.baomidou.mybatisplus.core.toolkit.StringPool.AMPERSAND;
import static com.baomidou.mybatisplus.core.toolkit.StringPool.EQUALS;

/**
 * @author: aman
 * @className CommonUtil
 * @description
 * @date 2025/2/1 19:58
 */
public class CommonUtil {

    /**
     * 将JSON字符串转换为顺序的json str，包括所有嵌套的对象和数组，并过滤掉值为""或null的字段。
     *
     * @param jsonStr JSON格式的字符串
     * @return json str
     */
    public static String jsonToSortedJson(String jsonStr) {
        if (StrUtil.isBlank(jsonStr)) {
            throw new IllegalArgumentException("JSON string cannot be empty");
        }
        JsonUtil.isValidJson(jsonStr);
        JsonNode rootNode = JsonUtil.getJsonRootNode(jsonStr);
        Object sortedObject = convertJsonNode(rootNode, new TreeMap<>());
        return JsonUtil.toJson(sortedObject);
    }


    /**
     * map 排序拼接成字符串
     *
     * @param params
     * @return string
     */
    public static String mapSortToString(Map<String, String> params) {
        if (null == params) {
            throw new IllegalArgumentException("params cannot be empty");
        }
        return params.entrySet().stream()
                .sorted(Map.Entry.<String, String>comparingByKey())
                .map(entry -> entry.getKey() + EQUALS + entry.getValue())
                .collect(Collectors.joining(AMPERSAND));
    }


    private static Object convertJsonNode(JsonNode node, TreeMap<String, Object> treeMap) {
        if (node.isObject()) {
            ObjectNode objectNode = (ObjectNode) node;
            objectNode.fields().forEachRemaining(entry -> {
                Object convertedValue = convertJsonNode(entry.getValue(), new TreeMap<>());
                // 过滤掉值为""或null的字段
                if (convertedValue != null && !convertedValue.toString().trim().isEmpty()) {
                    treeMap.put(entry.getKey(), convertedValue);
                }
            });
            return treeMap;
        } else if (node.isArray()) {
            ArrayNode arrayNode = (ArrayNode) node;
            List<Object> list = new ArrayList<>();
            for (JsonNode arrayElement : arrayNode) {
                Object convertedValue = convertJsonNode(arrayElement, new TreeMap<>());
                // 对于数组中的元素，同样过滤掉值为""或null的项
                if (convertedValue != null && !convertedValue.toString().trim().isEmpty()) {
                    list.add(convertedValue);
                }
            }
            return list;
        } else {
            // 处理基本类型：字符串、数字、布尔值和null
            if (node.isTextual()) {
                String textValue = node.asText();
                return textValue.isEmpty() ? null : textValue;
            } else if (node.isInt() || node.isLong() || node.isDouble() || node.isBoolean()) {
                return node.asText();
            } else if (node.isNull()) {
                return null;
            } else {
                return node.toString(); // 对于其他类型，直接返回其字符串表示形式
            }
        }
    }
}
